package com.dragon.modules.yuegou.query.member;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.dragon.modules.yuegou.entity.member.PtTurntableEntity;
import com.dragon.modules.yuegou.enums.member.PtTurntableCountWay;
import com.dragon.modules.yuegou.mybatis.Condition;
import com.dragon.modules.yuegou.mybatis.Query;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonUnwrapped;

import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * 积分大转盘表 动态查询条件
 * 
 * @author pbuilder generated
 * @date 2021-12-23 17:00:10
 * @version 2.0
 */
@JsonInclude(Include.NON_NULL)
public class PtTurntableQuery extends PtTurntableEntity implements Query<PtTurntableEntity> {

    /** id查询条件 */
	@JsonUnwrapped(prefix = "id")
	private Condition<String> idCondition;

    /** 商圈id查询条件 */
	@JsonUnwrapped(prefix = "busdId")
	private Condition<String> busdIdCondition;

    /** 抽奖标题查询条件 */
	@JsonUnwrapped(prefix = "title")
	private Condition<String> titleCondition;

    /** 开始时间查询条件 */
	@JsonUnwrapped(prefix = "startTime")
	private Condition<LocalDateTime> startTimeCondition;

    /** 结束时间查询条件 */
	@JsonUnwrapped(prefix = "endTime")
	private Condition<LocalDateTime> endTimeCondition;

    /** 中奖文案查询条件 */
	@JsonUnwrapped(prefix = "prizeContent")
	private Condition<String> prizeContentCondition;

    /** 重复中奖文案查询条件 */
	@JsonUnwrapped(prefix = "prizeRepeatContent")
	private Condition<String> prizeRepeatContentCondition;

    /** 未中奖文案查询条件 */
	@JsonUnwrapped(prefix = "missPrizeContent")
	private Condition<String> missPrizeContentCondition;

    /** 消耗积分查询条件 */
	@JsonUnwrapped(prefix = "consumePoint")
	private Condition<Integer> consumePointCondition;

    /** 中奖最大次数查询条件 */
	@JsonUnwrapped(prefix = "maxCount")
	private Condition<Integer> maxCountCondition;

    /** 每人每天抽奖次数查询条件 */
	@JsonUnwrapped(prefix = "maxExtractCount")
	private Condition<Integer> maxExtractCountCondition;

    /** 抽奖规则说明查询条件 */
	@JsonUnwrapped(prefix = "explain")
	private Condition<String> explainCondition;

    /** 中奖概率查询条件 */
	@JsonUnwrapped(prefix = "gainProbability")
	private Condition<BigDecimal> gainProbabilityCondition;

    /** 不中奖概率查询条件 */
	@JsonUnwrapped(prefix = "missProbability")
	private Condition<BigDecimal> missProbabilityCondition;

    /** 入口图标查询条件 */
	@JsonUnwrapped(prefix = "indexIcon")
	private Condition<String> indexIconCondition;

    /** 顶部图 查询条件 */
	@JsonUnwrapped(prefix = "turntableTopImg")
	private Condition<String> turntableTopImgCondition;

    /** 活动背景图查询条件 */
	@JsonUnwrapped(prefix = "turntableActImg")
	private Condition<String> turntableActImgCondition;

    /** 转盘背景图查询条件 */
	@JsonUnwrapped(prefix = "turntableBackImg")
	private Condition<String> turntableBackImgCondition;

    /** 应用系统查询条件 */
	@JsonUnwrapped(prefix = "applicationCode")
	private Condition<String> applicationCodeCondition;

    /** 启用状态查询条件 */
	@JsonUnwrapped(prefix = "enableStatus")
	private Condition<Boolean> enableStatusCondition;
	
    /** [枚举]抽奖概率计算：0-按商品总数计算-ALL、1-按商品剩余数计算-SURPLUS查询条件 */
	@JsonUnwrapped(prefix = "countWay")
	private Condition<PtTurntableCountWay> countWayCondition;

    /** 查询条件 */
	@JsonUnwrapped(prefix = "createdTime")
	private Condition<LocalDateTime> createdTimeCondition;

    /** 查询条件 */
	@JsonUnwrapped(prefix = "createdBy")
	private Condition<String> createdByCondition;

    /** 查询条件 */
	@JsonUnwrapped(prefix = "modifiedTime")
	private Condition<LocalDateTime> modifiedTimeCondition;

    /** 查询条件 */
	@JsonUnwrapped(prefix = "modifiedBy")
	private Condition<String> modifiedByCondition;

    /** 删除 0-未删除；1-已删除查询条件 */
	@JsonUnwrapped(prefix = "del")
	private Condition<Boolean> delCondition;

    /** 查询条件 */
	@JsonUnwrapped(prefix = "delTime")
	private Condition<LocalDateTime> delTimeCondition;

    /** 查询条件 */
	@JsonUnwrapped(prefix = "delBy")
	private Condition<String> delByCondition;

	/**
	 * 构造一个查询条件对象
	 */
	public PtTurntableQuery() {
		super();
	}

	/**
	 * 依据实体对象构造一个查询条件对象
	 * 
	 * @param entity 实体对象
	 */
	public PtTurntableQuery(PtTurntableEntity entity) {
		super(entity);
	}

	/**
	 * 依据其它查询条件对象的信息构造一个查询条件对象
	 * 
	 * @param other 查询条件对象
	 */
	public PtTurntableQuery(PtTurntableQuery other) {
		super(other);
		if (other.idCondition != null) {
			this.idCondition = other.idCondition.copy();
		}
		if (other.busdIdCondition != null) {
			this.busdIdCondition = other.busdIdCondition.copy();
		}
		if (other.titleCondition != null) {
			this.titleCondition = other.titleCondition.copy();
		}
		if (other.startTimeCondition != null) {
			this.startTimeCondition = other.startTimeCondition.copy();
		}
		if (other.endTimeCondition != null) {
			this.endTimeCondition = other.endTimeCondition.copy();
		}
		if (other.prizeContentCondition != null) {
			this.prizeContentCondition = other.prizeContentCondition.copy();
		}
		if (other.prizeRepeatContentCondition != null) {
			this.prizeRepeatContentCondition = other.prizeRepeatContentCondition.copy();
		}
		if (other.missPrizeContentCondition != null) {
			this.missPrizeContentCondition = other.missPrizeContentCondition.copy();
		}
		if (other.consumePointCondition != null) {
			this.consumePointCondition = other.consumePointCondition.copy();
		}
		if (other.maxCountCondition != null) {
			this.maxCountCondition = other.maxCountCondition.copy();
		}
		if (other.maxExtractCountCondition != null) {
			this.maxExtractCountCondition = other.maxExtractCountCondition.copy();
		}
		if (other.explainCondition != null) {
			this.explainCondition = other.explainCondition.copy();
		}
		if (other.gainProbabilityCondition != null) {
			this.gainProbabilityCondition = other.gainProbabilityCondition.copy();
		}
		if (other.missProbabilityCondition != null) {
			this.missProbabilityCondition = other.missProbabilityCondition.copy();
		}
		this.setOther(other);
	}

	private void setOther(PtTurntableQuery other){
		if(other.indexIconCondition != null) {
			this.indexIconCondition = other.indexIconCondition.copy();
		}
		if(other.turntableTopImgCondition != null) {
			this.turntableTopImgCondition = other.turntableTopImgCondition.copy();
		}
		if(other.turntableActImgCondition != null) {
			this.turntableActImgCondition = other.turntableActImgCondition.copy();
		}
		if(other.turntableBackImgCondition != null) {
			this.turntableBackImgCondition = other.turntableBackImgCondition.copy();
		}
		if(other.applicationCodeCondition != null) {
			this.applicationCodeCondition = other.applicationCodeCondition.copy();
		}
		if(other.enableStatusCondition != null) {
			this.enableStatusCondition = other.enableStatusCondition.copy();
		}
		if(other.countWayCondition != null) {
			this.countWayCondition = other.countWayCondition.copy();
		}
		if(other.createdTimeCondition != null) {
			this.createdTimeCondition = other.createdTimeCondition.copy();
		}
		if(other.createdByCondition != null) {
			this.createdByCondition = other.createdByCondition.copy();
		}
		if(other.modifiedTimeCondition != null) {
			this.modifiedTimeCondition = other.modifiedTimeCondition.copy();
		}
		if(other.modifiedByCondition != null) {
			this.modifiedByCondition = other.modifiedByCondition.copy();
		}
		if(other.delCondition != null) {
			this.delCondition = other.delCondition.copy();
		}
		if(other.delTimeCondition != null) {
			this.delTimeCondition = other.delTimeCondition.copy();
		}
		if(other.delByCondition != null) {
			this.delByCondition = other.delByCondition.copy();
		}
	}

	@Override
	public QueryWrapper<PtTurntableEntity> toQueryWrapper() {
		QueryWrapper<PtTurntableEntity> wrapper = new QueryWrapper<>(this);
		if (idCondition != null) {
			idCondition.toWrapper(wrapper, COL_ID);
		}
		if (busdIdCondition != null) {
			busdIdCondition.toWrapper(wrapper, COL_BUSD_ID);
		}
		if (titleCondition != null) {
			titleCondition.toWrapper(wrapper, COL_TITLE);
		}
		if (startTimeCondition != null) {
			startTimeCondition.toWrapper(wrapper, COL_START_TIME);
		}
		if (endTimeCondition != null) {
			endTimeCondition.toWrapper(wrapper, COL_END_TIME);
		}
		if (prizeContentCondition != null) {
			prizeContentCondition.toWrapper(wrapper, COL_PRIZE_CONTENT);
		}
		if (prizeRepeatContentCondition != null) {
			prizeRepeatContentCondition.toWrapper(wrapper, COL_PRIZE_REPEAT_CONTENT);
		}
		if (missPrizeContentCondition != null) {
			missPrizeContentCondition.toWrapper(wrapper, COL_MISS_PRIZE_CONTENT);
		}
		if (consumePointCondition != null) {
			consumePointCondition.toWrapper(wrapper, COL_CONSUME_POINT);
		}
		if (maxCountCondition != null) {
			maxCountCondition.toWrapper(wrapper, COL_MAX_COUNT);
		}
		if (maxExtractCountCondition != null) {
			maxExtractCountCondition.toWrapper(wrapper, COL_MAX_EXTRACT_COUNT);
		}
		if (explainCondition != null) {
			explainCondition.toWrapper(wrapper, COL_EXPLAIN);
		}
		if (gainProbabilityCondition != null) {
			gainProbabilityCondition.toWrapper(wrapper, COL_GAIN_PROBABILITY);
		}
		if (missProbabilityCondition != null) {
			missProbabilityCondition.toWrapper(wrapper, COL_MISS_PROBABILITY);
		}
		return getQueryWrapper(wrapper);
	}

	private QueryWrapper<PtTurntableEntity> getQueryWrapper(QueryWrapper<PtTurntableEntity> wrapper){

		if (indexIconCondition != null) {
			indexIconCondition.toWrapper(wrapper, COL_INDEX_ICON);
		}
		if (turntableTopImgCondition != null) {
			turntableTopImgCondition.toWrapper(wrapper, COL_TURNTABLE_TOP_IMG);
		}
		if (turntableActImgCondition != null) {
			turntableActImgCondition.toWrapper(wrapper, COL_TURNTABLE_ACT_IMG);
		}
		if (turntableBackImgCondition != null) {
			turntableBackImgCondition.toWrapper(wrapper, COL_TURNTABLE_BACK_IMG);
		}
		if (applicationCodeCondition != null) {
			applicationCodeCondition.toWrapper(wrapper, COL_APPLICATION_CODE);
		}
		if (enableStatusCondition != null) {
			enableStatusCondition.toWrapper(wrapper, COL_ENABLE_STATUS);
		}
		if (countWayCondition != null) {
			countWayCondition.toWrapper(wrapper, COL_COUNT_WAY);
		}
		if (createdTimeCondition != null) {
			createdTimeCondition.toWrapper(wrapper, COL_CREATED_TIME);
		}
		if (createdByCondition != null) {
			createdByCondition.toWrapper(wrapper, COL_CREATED_BY);
		}
		if (modifiedTimeCondition != null) {
			modifiedTimeCondition.toWrapper(wrapper, COL_MODIFIED_TIME);
		}
		if (modifiedByCondition != null) {
			modifiedByCondition.toWrapper(wrapper, COL_MODIFIED_BY);
		}
		if (delCondition != null) {
			delCondition.toWrapper(wrapper, COL_DEL);
		}
		if (delTimeCondition != null) {
			delTimeCondition.toWrapper(wrapper, COL_DEL_TIME);
		}
		if (delByCondition != null) {
			delByCondition.toWrapper(wrapper, COL_DEL_BY);
		}
		return wrapper;
	}

	/**
	 * 构造并返回id查询条件
	 * 
	 * @return idCondition id查询条件
	 */
	public Condition<String> id() {
		this.idCondition = new Condition<>();
		return this.idCondition;
	}
	
	/**
	 * 获取id查询条件
	 * 
	 * @return idCondition id查询条件
	 */
	public Condition<String> getIdCondition() {
		return idCondition;
	}

	/**
	 * 设置id查询条件
	 * 
	 * @param idCondition id查询条件
	 */
	public void setIdCondition(Condition<String> idCondition) {
		this.idCondition = idCondition;
	}

	/**
	 * 构造并返回商圈id查询条件
	 * 
	 * @return busdIdCondition 商圈id查询条件
	 */
	public Condition<String> busdId() {
		this.busdIdCondition = new Condition<>();
		return this.busdIdCondition;
	}
	
	/**
	 * 获取商圈id查询条件
	 * 
	 * @return busdIdCondition 商圈id查询条件
	 */
	public Condition<String> getBusdIdCondition() {
		return busdIdCondition;
	}

	/**
	 * 设置商圈id查询条件
	 * 
	 * @param busdIdCondition 商圈id查询条件
	 */
	public void setBusdIdCondition(Condition<String> busdIdCondition) {
		this.busdIdCondition = busdIdCondition;
	}

	/**
	 * 构造并返回抽奖标题查询条件
	 * 
	 * @return titleCondition 抽奖标题查询条件
	 */
	public Condition<String> title() {
		this.titleCondition = new Condition<>();
		return this.titleCondition;
	}
	
	/**
	 * 获取抽奖标题查询条件
	 * 
	 * @return titleCondition 抽奖标题查询条件
	 */
	public Condition<String> getTitleCondition() {
		return titleCondition;
	}

	/**
	 * 设置抽奖标题查询条件
	 * 
	 * @param titleCondition 抽奖标题查询条件
	 */
	public void setTitleCondition(Condition<String> titleCondition) {
		this.titleCondition = titleCondition;
	}

	/**
	 * 构造并返回开始时间查询条件
	 * 
	 * @return startTimeCondition 开始时间查询条件
	 */
	public Condition<LocalDateTime> startTime() {
		this.startTimeCondition = new Condition<>();
		return this.startTimeCondition;
	}
	
	/**
	 * 获取开始时间查询条件
	 * 
	 * @return startTimeCondition 开始时间查询条件
	 */
	public Condition<LocalDateTime> getStartTimeCondition() {
		return startTimeCondition;
	}

	/**
	 * 设置开始时间查询条件
	 * 
	 * @param startTimeCondition 开始时间查询条件
	 */
	public void setStartTimeCondition(Condition<LocalDateTime> startTimeCondition) {
		this.startTimeCondition = startTimeCondition;
	}

	/**
	 * 构造并返回结束时间查询条件
	 * 
	 * @return endTimeCondition 结束时间查询条件
	 */
	public Condition<LocalDateTime> endTime() {
		this.endTimeCondition = new Condition<>();
		return this.endTimeCondition;
	}
	
	/**
	 * 获取结束时间查询条件
	 * 
	 * @return endTimeCondition 结束时间查询条件
	 */
	public Condition<LocalDateTime> getEndTimeCondition() {
		return endTimeCondition;
	}

	/**
	 * 设置结束时间查询条件
	 * 
	 * @param endTimeCondition 结束时间查询条件
	 */
	public void setEndTimeCondition(Condition<LocalDateTime> endTimeCondition) {
		this.endTimeCondition = endTimeCondition;
	}

	/**
	 * 构造并返回中奖文案查询条件
	 * 
	 * @return prizeContentCondition 中奖文案查询条件
	 */
	public Condition<String> prizeContent() {
		this.prizeContentCondition = new Condition<>();
		return this.prizeContentCondition;
	}
	
	/**
	 * 获取中奖文案查询条件
	 * 
	 * @return prizeContentCondition 中奖文案查询条件
	 */
	public Condition<String> getPrizeContentCondition() {
		return prizeContentCondition;
	}

	/**
	 * 设置中奖文案查询条件
	 * 
	 * @param prizeContentCondition 中奖文案查询条件
	 */
	public void setPrizeContentCondition(Condition<String> prizeContentCondition) {
		this.prizeContentCondition = prizeContentCondition;
	}

	/**
	 * 构造并返回重复中奖文案查询条件
	 * 
	 * @return prizeRepeatContentCondition 重复中奖文案查询条件
	 */
	public Condition<String> prizeRepeatContent() {
		this.prizeRepeatContentCondition = new Condition<>();
		return this.prizeRepeatContentCondition;
	}
	
	/**
	 * 获取重复中奖文案查询条件
	 * 
	 * @return prizeRepeatContentCondition 重复中奖文案查询条件
	 */
	public Condition<String> getPrizeRepeatContentCondition() {
		return prizeRepeatContentCondition;
	}

	/**
	 * 设置重复中奖文案查询条件
	 * 
	 * @param prizeRepeatContentCondition 重复中奖文案查询条件
	 */
	public void setPrizeRepeatContentCondition(Condition<String> prizeRepeatContentCondition) {
		this.prizeRepeatContentCondition = prizeRepeatContentCondition;
	}

	/**
	 * 构造并返回未中奖文案查询条件
	 * 
	 * @return missPrizeContentCondition 未中奖文案查询条件
	 */
	public Condition<String> missPrizeContent() {
		this.missPrizeContentCondition = new Condition<>();
		return this.missPrizeContentCondition;
	}
	
	/**
	 * 获取未中奖文案查询条件
	 * 
	 * @return missPrizeContentCondition 未中奖文案查询条件
	 */
	public Condition<String> getMissPrizeContentCondition() {
		return missPrizeContentCondition;
	}

	/**
	 * 设置未中奖文案查询条件
	 * 
	 * @param missPrizeContentCondition 未中奖文案查询条件
	 */
	public void setMissPrizeContentCondition(Condition<String> missPrizeContentCondition) {
		this.missPrizeContentCondition = missPrizeContentCondition;
	}

	/**
	 * 构造并返回消耗积分查询条件
	 * 
	 * @return consumePointCondition 消耗积分查询条件
	 */
	public Condition<Integer> consumePoint() {
		this.consumePointCondition = new Condition<>();
		return this.consumePointCondition;
	}
	
	/**
	 * 获取消耗积分查询条件
	 * 
	 * @return consumePointCondition 消耗积分查询条件
	 */
	public Condition<Integer> getConsumePointCondition() {
		return consumePointCondition;
	}

	/**
	 * 设置消耗积分查询条件
	 * 
	 * @param consumePointCondition 消耗积分查询条件
	 */
	public void setConsumePointCondition(Condition<Integer> consumePointCondition) {
		this.consumePointCondition = consumePointCondition;
	}

	/**
	 * 构造并返回中奖最大次数查询条件
	 * 
	 * @return maxCountCondition 中奖最大次数查询条件
	 */
	public Condition<Integer> maxCount() {
		this.maxCountCondition = new Condition<>();
		return this.maxCountCondition;
	}
	
	/**
	 * 获取中奖最大次数查询条件
	 * 
	 * @return maxCountCondition 中奖最大次数查询条件
	 */
	public Condition<Integer> getMaxCountCondition() {
		return maxCountCondition;
	}

	/**
	 * 设置中奖最大次数查询条件
	 * 
	 * @param maxCountCondition 中奖最大次数查询条件
	 */
	public void setMaxCountCondition(Condition<Integer> maxCountCondition) {
		this.maxCountCondition = maxCountCondition;
	}

	/**
	 * 构造并返回每人每天抽奖次数查询条件
	 * 
	 * @return maxExtractCountCondition 每人每天抽奖次数查询条件
	 */
	public Condition<Integer> maxExtractCount() {
		this.maxExtractCountCondition = new Condition<>();
		return this.maxExtractCountCondition;
	}
	
	/**
	 * 获取每人每天抽奖次数查询条件
	 * 
	 * @return maxExtractCountCondition 每人每天抽奖次数查询条件
	 */
	public Condition<Integer> getMaxExtractCountCondition() {
		return maxExtractCountCondition;
	}

	/**
	 * 设置每人每天抽奖次数查询条件
	 * 
	 * @param maxExtractCountCondition 每人每天抽奖次数查询条件
	 */
	public void setMaxExtractCountCondition(Condition<Integer> maxExtractCountCondition) {
		this.maxExtractCountCondition = maxExtractCountCondition;
	}

	/**
	 * 构造并返回抽奖规则说明查询条件
	 * 
	 * @return explainCondition 抽奖规则说明查询条件
	 */
	public Condition<String> explain() {
		this.explainCondition = new Condition<>();
		return this.explainCondition;
	}
	
	/**
	 * 获取抽奖规则说明查询条件
	 * 
	 * @return explainCondition 抽奖规则说明查询条件
	 */
	public Condition<String> getExplainCondition() {
		return explainCondition;
	}

	/**
	 * 设置抽奖规则说明查询条件
	 * 
	 * @param explainCondition 抽奖规则说明查询条件
	 */
	public void setExplainCondition(Condition<String> explainCondition) {
		this.explainCondition = explainCondition;
	}

	/**
	 * 构造并返回中奖概率查询条件
	 * 
	 * @return gainProbabilityCondition 中奖概率查询条件
	 */
	public Condition<BigDecimal> gainProbability() {
		this.gainProbabilityCondition = new Condition<>();
		return this.gainProbabilityCondition;
	}
	
	/**
	 * 获取中奖概率查询条件
	 * 
	 * @return gainProbabilityCondition 中奖概率查询条件
	 */
	public Condition<BigDecimal> getGainProbabilityCondition() {
		return gainProbabilityCondition;
	}

	/**
	 * 设置中奖概率查询条件
	 * 
	 * @param gainProbabilityCondition 中奖概率查询条件
	 */
	public void setGainProbabilityCondition(Condition<BigDecimal> gainProbabilityCondition) {
		this.gainProbabilityCondition = gainProbabilityCondition;
	}

	/**
	 * 构造并返回不中奖概率查询条件
	 * 
	 * @return missProbabilityCondition 不中奖概率查询条件
	 */
	public Condition<BigDecimal> missProbability() {
		this.missProbabilityCondition = new Condition<>();
		return this.missProbabilityCondition;
	}
	
	/**
	 * 获取不中奖概率查询条件
	 * 
	 * @return missProbabilityCondition 不中奖概率查询条件
	 */
	public Condition<BigDecimal> getMissProbabilityCondition() {
		return missProbabilityCondition;
	}

	/**
	 * 设置不中奖概率查询条件
	 * 
	 * @param missProbabilityCondition 不中奖概率查询条件
	 */
	public void setMissProbabilityCondition(Condition<BigDecimal> missProbabilityCondition) {
		this.missProbabilityCondition = missProbabilityCondition;
	}

	/**
	 * 构造并返回入口图标查询条件
	 * 
	 * @return indexIconCondition 入口图标查询条件
	 */
	public Condition<String> indexIcon() {
		this.indexIconCondition = new Condition<>();
		return this.indexIconCondition;
	}
	
	/**
	 * 获取入口图标查询条件
	 * 
	 * @return indexIconCondition 入口图标查询条件
	 */
	public Condition<String> getIndexIconCondition() {
		return indexIconCondition;
	}

	/**
	 * 设置入口图标查询条件
	 * 
	 * @param indexIconCondition 入口图标查询条件
	 */
	public void setIndexIconCondition(Condition<String> indexIconCondition) {
		this.indexIconCondition = indexIconCondition;
	}

	/**
	 * 构造并返回顶部图 查询条件
	 * 
	 * @return turntableTopImgCondition 顶部图 查询条件
	 */
	public Condition<String> turntableTopImg() {
		this.turntableTopImgCondition = new Condition<>();
		return this.turntableTopImgCondition;
	}
	
	/**
	 * 获取顶部图 查询条件
	 * 
	 * @return turntableTopImgCondition 顶部图 查询条件
	 */
	public Condition<String> getTurntableTopImgCondition() {
		return turntableTopImgCondition;
	}

	/**
	 * 设置顶部图 查询条件
	 * 
	 * @param turntableTopImgCondition 顶部图 查询条件
	 */
	public void setTurntableTopImgCondition(Condition<String> turntableTopImgCondition) {
		this.turntableTopImgCondition = turntableTopImgCondition;
	}

	/**
	 * 构造并返回活动背景图查询条件
	 * 
	 * @return turntableActImgCondition 活动背景图查询条件
	 */
	public Condition<String> turntableActImg() {
		this.turntableActImgCondition = new Condition<>();
		return this.turntableActImgCondition;
	}
	
	/**
	 * 获取活动背景图查询条件
	 * 
	 * @return turntableActImgCondition 活动背景图查询条件
	 */
	public Condition<String> getTurntableActImgCondition() {
		return turntableActImgCondition;
	}

	/**
	 * 设置活动背景图查询条件
	 * 
	 * @param turntableActImgCondition 活动背景图查询条件
	 */
	public void setTurntableActImgCondition(Condition<String> turntableActImgCondition) {
		this.turntableActImgCondition = turntableActImgCondition;
	}

	/**
	 * 构造并返回转盘背景图查询条件
	 * 
	 * @return turntableBackImgCondition 转盘背景图查询条件
	 */
	public Condition<String> turntableBackImg() {
		this.turntableBackImgCondition = new Condition<>();
		return this.turntableBackImgCondition;
	}
	
	/**
	 * 获取转盘背景图查询条件
	 * 
	 * @return turntableBackImgCondition 转盘背景图查询条件
	 */
	public Condition<String> getTurntableBackImgCondition() {
		return turntableBackImgCondition;
	}

	/**
	 * 设置转盘背景图查询条件
	 * 
	 * @param turntableBackImgCondition 转盘背景图查询条件
	 */
	public void setTurntableBackImgCondition(Condition<String> turntableBackImgCondition) {
		this.turntableBackImgCondition = turntableBackImgCondition;
	}

	/**
	 * 构造并返回应用系统查询条件
	 * 
	 * @return applicationCodeCondition 应用系统查询条件
	 */
	public Condition<String> applicationCode() {
		this.applicationCodeCondition = new Condition<>();
		return this.applicationCodeCondition;
	}
	
	/**
	 * 获取应用系统查询条件
	 * 
	 * @return applicationCodeCondition 应用系统查询条件
	 */
	public Condition<String> getApplicationCodeCondition() {
		return applicationCodeCondition;
	}

	/**
	 * 设置应用系统查询条件
	 * 
	 * @param applicationCodeCondition 应用系统查询条件
	 */
	public void setApplicationCodeCondition(Condition<String> applicationCodeCondition) {
		this.applicationCodeCondition = applicationCodeCondition;
	}

	/**
	 * 构造并返回启用状态查询条件
	 * 
	 * @return enableStatusCondition 启用状态查询条件
	 */
	public Condition<Boolean> enableStatus() {
		this.enableStatusCondition = new Condition<>();
		return this.enableStatusCondition;
	}
	
	/**
	 * 获取启用状态查询条件
	 * 
	 * @return enableStatusCondition 启用状态查询条件
	 */
	public Condition<Boolean> getEnableStatusCondition() {
		return enableStatusCondition;
	}

	/**
	 * 设置启用状态查询条件
	 * 
	 * @param enableStatusCondition 启用状态查询条件
	 */
	public void setEnableStatusCondition(Condition<Boolean> enableStatusCondition) {
		this.enableStatusCondition = enableStatusCondition;
	}
	
	/**
	 * 构造并返回[枚举]抽奖概率计算：0-按商品总数计算-ALL、1-按商品剩余数计算-SURPLUS查询条件
	 * 
	 * @return countWayCondition [枚举]抽奖概率计算：0-按商品总数计算-ALL、1-按商品剩余数计算-SURPLUS查询条件
	 */
	public Condition<PtTurntableCountWay> countWay() {
		this.countWayCondition = new Condition<>();
		return this.countWayCondition;
	}
	
	/**
	 * 获取[枚举]抽奖概率计算：0-按商品总数计算-ALL、1-按商品剩余数计算-SURPLUS查询条件
	 * 
	 * @return countWayCondition [枚举]抽奖概率计算：0-按商品总数计算-ALL、1-按商品剩余数计算-SURPLUS查询条件
	 */
	public Condition<PtTurntableCountWay> getCountWayCondition() {
		return countWayCondition;
	}

	/**
	 * 设置[枚举]抽奖概率计算：0-按商品总数计算-ALL、1-按商品剩余数计算-SURPLUS查询条件
	 * 
	 * @param countWayCondition [枚举]抽奖概率计算：0-按商品总数计算-ALL、1-按商品剩余数计算-SURPLUS查询条件
	 */
	public void setCountWayCondition(Condition<PtTurntableCountWay> countWayCondition) {
		this.countWayCondition = countWayCondition;
	}

	/**
	 * 构造并返回查询条件
	 * 
	 * @return createdTimeCondition 查询条件
	 */
	public Condition<LocalDateTime> createdTime() {
		this.createdTimeCondition = new Condition<>();
		return this.createdTimeCondition;
	}
	
	/**
	 * 获取查询条件
	 * 
	 * @return createdTimeCondition 查询条件
	 */
	public Condition<LocalDateTime> getCreatedTimeCondition() {
		return createdTimeCondition;
	}

	/**
	 * 设置查询条件
	 * 
	 * @param createdTimeCondition 查询条件
	 */
	public void setCreatedTimeCondition(Condition<LocalDateTime> createdTimeCondition) {
		this.createdTimeCondition = createdTimeCondition;
	}

	/**
	 * 构造并返回查询条件
	 * 
	 * @return createdByCondition 查询条件
	 */
	public Condition<String> createdBy() {
		this.createdByCondition = new Condition<>();
		return this.createdByCondition;
	}
	
	/**
	 * 获取查询条件
	 * 
	 * @return createdByCondition 查询条件
	 */
	public Condition<String> getCreatedByCondition() {
		return createdByCondition;
	}

	/**
	 * 设置查询条件
	 * 
	 * @param createdByCondition 查询条件
	 */
	public void setCreatedByCondition(Condition<String> createdByCondition) {
		this.createdByCondition = createdByCondition;
	}

	/**
	 * 构造并返回查询条件
	 * 
	 * @return modifiedTimeCondition 查询条件
	 */
	public Condition<LocalDateTime> modifiedTime() {
		this.modifiedTimeCondition = new Condition<>();
		return this.modifiedTimeCondition;
	}
	
	/**
	 * 获取查询条件
	 * 
	 * @return modifiedTimeCondition 查询条件
	 */
	public Condition<LocalDateTime> getModifiedTimeCondition() {
		return modifiedTimeCondition;
	}

	/**
	 * 设置查询条件
	 * 
	 * @param modifiedTimeCondition 查询条件
	 */
	public void setModifiedTimeCondition(Condition<LocalDateTime> modifiedTimeCondition) {
		this.modifiedTimeCondition = modifiedTimeCondition;
	}

	/**
	 * 构造并返回查询条件
	 * 
	 * @return modifiedByCondition 查询条件
	 */
	public Condition<String> modifiedBy() {
		this.modifiedByCondition = new Condition<>();
		return this.modifiedByCondition;
	}
	
	/**
	 * 获取查询条件
	 * 
	 * @return modifiedByCondition 查询条件
	 */
	public Condition<String> getModifiedByCondition() {
		return modifiedByCondition;
	}

	/**
	 * 设置查询条件
	 * 
	 * @param modifiedByCondition 查询条件
	 */
	public void setModifiedByCondition(Condition<String> modifiedByCondition) {
		this.modifiedByCondition = modifiedByCondition;
	}

	/**
	 * 构造并返回删除 0-未删除；1-已删除查询条件
	 * 
	 * @return delCondition 删除 0-未删除；1-已删除查询条件
	 */
	public Condition<Boolean> del() {
		this.delCondition = new Condition<>();
		return this.delCondition;
	}
	
	/**
	 * 获取删除 0-未删除；1-已删除查询条件
	 * 
	 * @return delCondition 删除 0-未删除；1-已删除查询条件
	 */
	public Condition<Boolean> getDelCondition() {
		return delCondition;
	}

	/**
	 * 设置删除 0-未删除；1-已删除查询条件
	 * 
	 * @param delCondition 删除 0-未删除；1-已删除查询条件
	 */
	public void setDelCondition(Condition<Boolean> delCondition) {
		this.delCondition = delCondition;
	}

	/**
	 * 构造并返回查询条件
	 * 
	 * @return delTimeCondition 查询条件
	 */
	public Condition<LocalDateTime> delTime() {
		this.delTimeCondition = new Condition<>();
		return this.delTimeCondition;
	}
	
	/**
	 * 获取查询条件
	 * 
	 * @return delTimeCondition 查询条件
	 */
	public Condition<LocalDateTime> getDelTimeCondition() {
		return delTimeCondition;
	}

	/**
	 * 设置查询条件
	 * 
	 * @param delTimeCondition 查询条件
	 */
	public void setDelTimeCondition(Condition<LocalDateTime> delTimeCondition) {
		this.delTimeCondition = delTimeCondition;
	}

	/**
	 * 构造并返回查询条件
	 * 
	 * @return delByCondition 查询条件
	 */
	public Condition<String> delBy() {
		this.delByCondition = new Condition<>();
		return this.delByCondition;
	}
	
	/**
	 * 获取查询条件
	 * 
	 * @return delByCondition 查询条件
	 */
	public Condition<String> getDelByCondition() {
		return delByCondition;
	}

	/**
	 * 设置查询条件
	 * 
	 * @param delByCondition 查询条件
	 */
	public void setDelByCondition(Condition<String> delByCondition) {
		this.delByCondition = delByCondition;
	}

}
